home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / MenuHack / MenuHackSource.sit / MenuHack.c < prev    next >
C/C++ Source or Header  |  1996-06-21  |  6KB  |  220 lines
  1. /*------------------------------------------------------------------------------
  2. #
  3. #    MenuHack.c - C source for helper app for menu hack (handles bookmarks in
  4. #    Netscape, from an App, getting stuff from WebArranger.  Yes, it's a cross-app patcher!
  5. #
  6. #    Copyright © CE Software, Inc., Inc. 1996
  7. #    All rights reserved.
  8. #
  9. #    This is pretty much just a basic shell.  The heavy lifting is done in MHHandler.c
  10. #
  11. ------------------------------------------------------------------------------*/
  12.  
  13. #include "MenuHackData.h"        /* bring in all the #defines for MenuHack */
  14. #include <PLStringFuncs.h>        /* some special string handling stuff */
  15. #include <string.h>
  16.  
  17. /* The "g" prefix is used to emphasize that a variable is global. */
  18.  
  19. /* GInBackground is maintained by our osEvent handling routines. Any part of
  20.    the program can check it to find out if it is currently in the background. */
  21. Boolean        gInBackground;        /* maintained by Initialize and DoEvent */
  22. Boolean        gDoneFlag = true;
  23.  
  24. /* Here are declarations for all of the C routines. In MPW 3.0 and later we can use
  25.    actual prototypes for parameter type checking. */
  26. void EventLoop( void );
  27. void DoEvent( EventRecord *event );
  28. void DoMenuCommand( long menuResult );
  29. void Initialize( void );
  30.  
  31.  
  32. /* Define HiWrd and LoWrd macros for efficiency. */
  33. #define HiWrd(aLong)    (((aLong) >> 16) & 0xFFFF)
  34. #define LoWrd(aLong)    ((aLong) & 0xFFFF)
  35.  
  36. /* Define TopLeft and BotRight macros for convenience. Notice the implicit
  37.    dependency on the ordering of fields within a Rect */
  38. #define TopLeft(aRect)    (* (Point *) &(aRect).top)
  39. #define BotRight(aRect)    (* (Point *) &(aRect).bottom)
  40.  
  41.  
  42. #pragma segment Main
  43. main()
  44. {
  45.     SetApplLimit(GetApplLimit()-32768); //give an additional 32K to stack
  46.     MaxApplZone();                    /* expand the heap so code segments load at the top */
  47.  
  48.     Initialize();                    /* initialize the program */
  49.     
  50.     InitWHandler();
  51.     
  52.     EventLoop();                    /* call the main event loop */
  53.     
  54.     CloseWHandler();
  55. }
  56.  
  57.  
  58. /*    Get events forever, and handle them by calling DoEvent.
  59.     Get the events by calling WaitNextEvent. */
  60.  
  61. void EventLoop()
  62. {
  63.     RgnHandle    cursorRgn;
  64.     Boolean        gotEvent;
  65.     EventRecord    event;
  66.     WindowPtr    aWindow;
  67.     
  68.     cursorRgn = NewRgn();            /* we’ll pass WNE an empty region the 1st time thru */
  69.     do {
  70.         gotEvent = WaitNextEvent(everyEvent, &event, 5, nil);
  71.         PollWHandler(event.where);    // Call our routine that checks to see if some AppleEvent work is needed!
  72.         if ( gotEvent ) {
  73.             DoEvent(&event);
  74.         }
  75.     } while ( gDoneFlag );
  76.     
  77.     gotEvent = true;
  78. } /*EventLoop*/
  79.  
  80.  
  81. /* Do the right thing for an event. Determine what kind of event it is, and call
  82.  the appropriate routines. */
  83.  
  84. void DoEvent(event)
  85.     EventRecord    *event;
  86. {
  87.  
  88.     short        part, err;
  89.     WindowPtr    window;
  90.     Boolean        hit;
  91.     char        key;
  92.     Point        aPoint;
  93.  
  94.     switch ( event->what ) {
  95.         case kHighLevelEvent:
  96.             err = AEProcessAppleEvent( event ) ;
  97.             break;
  98.         case mouseDown:
  99.             part = FindWindow(event->where, &window);
  100.             switch ( part ) {
  101.                 case inMenuBar:                /* process a mouse menu command (if any) */
  102.                     DoMenuCommand(MenuSelect(event->where));
  103.                     break;
  104.                 case inSysWindow:            /* let the system handle the mouseDown */
  105.                     SystemClick(event, window);
  106.                     break;
  107.             }
  108.             break;
  109.         case keyDown:
  110.         case autoKey:                        /* check for menukey equivalents */
  111.             key = event->message & charCodeMask;
  112.             if ( event->modifiers & cmdKey )            /* Command key down */
  113.                 if ( event->what == keyDown ) {
  114.                     DoMenuCommand(MenuKey(key));
  115.                 }
  116.             break;
  117.         case diskEvt:
  118.             if ( HiWord(event->message) != noErr ) {
  119.                 SetPt(&aPoint, kDILeft, kDITop);
  120.                 err = DIBadMount(aPoint, event->message);
  121.             }
  122.             break;
  123.         case kOSEvent:
  124.             switch ((event->message >> 24) & 0x0FF) {        /* high byte of message */
  125.                 case kSuspendResumeMessage:        /* suspend/resume is also an activate/deactivate */
  126.                     gInBackground = (event->message & kResumeMask) == 0;
  127.                     break;
  128.             }
  129.             break;
  130.     }
  131. } /*DoEvent*/
  132.  
  133. /*    This is called when an item is chosen from the menu bar (after calling
  134.     MenuSelect or MenuKey). It performs the right operation for each command.
  135.     It is good to have both the result of MenuSelect and MenuKey go to
  136.     one routine like this to keep everything organized. */
  137.  
  138. void DoMenuCommand(menuResult)
  139.     long        menuResult;
  140. {
  141.     short        menuID;                /* the resource ID of the selected menu */
  142.     short        menuItem;            /* the item number of the selected menu */
  143.     short        itemHit;
  144.     Str255        daName;
  145.     short        daRefNum;
  146.     Boolean        handledByDA;
  147.  
  148.     menuID = HiWord(menuResult);    /* use macros for efficiency to... */
  149.     menuItem = LoWord(menuResult);    /* get menu item number and menu number */
  150.     switch ( menuID ) {
  151.         case mApple:
  152.             switch ( menuItem ) {
  153.                 case iAbout:        /* bring up alert for About */
  154.                     itemHit = Alert(rAboutAlert, nil);
  155.                     break;
  156.                 default:            /* all non-About items in this menu are DAs */
  157.                     /* type Str255 is an array in MPW 3 */
  158.                     GetItem(GetMHandle(mApple), menuItem, daName);
  159.                     daRefNum = OpenDeskAcc(daName);
  160.                     break;
  161.             }
  162.             break;
  163.         case mFile:
  164.             switch ( menuItem ) {
  165.                 case iQuit:
  166.                     gDoneFlag = false;
  167.                     break;
  168.             }
  169.             break;
  170.         case mEdit:                    /* call SystemEdit for DA editing & MultiFinder */
  171.             handledByDA = SystemEdit(menuItem-1);    /* since we don’t do any Editing */
  172.             break;
  173.     }
  174.     HiliteMenu(0);                    /* unhighlight what MenuSelect (or MenuKey) hilited */
  175. } /*DoMenuCommand*/
  176.  
  177.  
  178. void Initialize()
  179. {
  180.     Handle        menuBar;
  181.     WindowPtr    window;
  182.     long        total, contig;
  183.     EventRecord event;
  184.     short        count;
  185.     long        x;
  186.     OSErr        err;
  187.  
  188.     gInBackground = false;
  189.     
  190.     InitGraf((Ptr) &qd.thePort);
  191.     InitFonts();
  192.     InitWindows();
  193.     InitMenus();
  194.     TEInit();
  195.     InitDialogs(nil);
  196.     InitCursor();
  197.     
  198.     InstallAEHandlers();
  199.     menuBar = GetNewMBar(rMenuBar);            /* read menus into menu bar */
  200.     if ( menuBar == nil ) ExitToShell();
  201.     SetMenuBar(menuBar);                    /* install menus */
  202.     DisposHandle(menuBar);
  203.     AddResMenu(GetMHandle(mApple), 'DRVR');    /* add DA names to Apple menu */
  204.     DrawMenuBar();
  205.     
  206.     for (count = 1; count <= 3; count++)
  207.     {
  208.         if (WaitNextEvent(everyEvent, &event, 5, nil))
  209.         {
  210.             if (event.what==kHighLevelEvent)
  211.             {
  212.             err = AEProcessAppleEvent( &event ) ;
  213.             }
  214.  
  215.         }
  216.     }
  217.     
  218. } /*Initialize*/
  219.  
  220.